Python Django Middleware: Potek obdelave zahtev

Django, visokorazviti spletni okvir Python, ponuja robusten in eleganten pristop k spletnemu razvoju. V središču njegove funkcionalnosti je potek obdelave zahtev, zaporedje operacij, ki pretvarja neobdelane dohodne zahteve v smiselne odgovore. Ključna komponenta tega poteka je middleware, ki razvijalcem omogoča, da vstavijo logiko in vedenje po meri na različnih točkah med obdelavo zahtev.

Razumevanje cikla obdelave zahtev v Djangu

Preden se poglobimo v middleware, je bistveno razumeti temeljni potek zahteve v Djangu. Ko uporabnik pošlje zahtevo v aplikacijo Django, se običajno zgodijo naslednji koraki:

• WSGI strežnik prejme zahtevo: WSGI (Web Server Gateway Interface) strežnik (kot sta Gunicorn ali uWSGI) prejme zahtevo HTTP od odjemalca.
• Obdelava middleware (dohodne zahteve): Zahteva gre skozi sklad middleware, v vrstnem redu, določenem v datoteki `settings.py`. Vsaka komponenta middleware ima priložnost obdelati zahtevo, preden doseže pogled. Tukaj se izvajajo avtentikacija, avtorizacija, upravljanje sej in druge naloge predobdelave.
• Razrešitev URL-ja: Razreševalec URL-jev Djanga preveri zahtevani URL in določi ustrezno funkcijo pogleda za obravnavo.
• Izvedba pogleda: Izvede se identificirana funkcija pogleda, ki običajno vključuje interakcijo z bazo podatkov, generiranje vsebine odgovora in pripravo odgovora HTTP.
• Obdelava middleware (odhodne zahteve): Odgovor se nato posreduje nazaj skozi sklad middleware, v obratnem vrstnem redu. Tukaj se lahko izvajajo naloge, kot so dodajanje glave, stiskanje odgovora in nastavitev piškotkov.
• WSGI strežnik pošlje odgovor: WSGI strežnik končno pošlje odgovor HTTP nazaj odjemalcu.

Kaj je Django Middleware?

Django middleware je okvir kljuk v obdelavo zahtev/odgovorov Djanga. Gre za vtičljiv nabor razredov, ki globalno spreminjajo vhod ali izhod Djanga. Zamislite si ga kot niz filtrov, ki se nahajajo med spletnim strežnikom in funkcijami pogleda, prestrezajo in spreminjajo zahteve in odgovore.

Middleware vam omogoča:

• Spremenite zahtevo, preden doseže pogled (npr. dodajte glave, izvedite avtentikacijo).
• Spremenite odgovor, preden je poslan odjemalcu (npr. dodajte glave, stisnite vsebino).
• Odločite se, ali boste zahtevi dovolili ali prepovedali, da doseže pogled.
• Izvedite dejanja pred in po izvedbi pogleda (npr. beleženje, profiliranje).

Privzeti middleware Djanga obravnava osnovne funkcionalnosti, kot so:

• Upravljanje sej
• Avtentikacija
• Prikaz sporočil (npr. sporočila o uspehu in napakah)
• Stiskanje GZIP

Zakaj uporabljati Middleware? Prednosti in koristi

Middleware ponuja več pomembnih prednosti:

• Ponovna uporabnost kode: Logiko middleware je mogoče ponovno uporabiti v več pogledih in projektih, kar preprečuje podvojeno kodo. Na primer, namesto da bi avtentikacijo implementirali v vsakem pogledu, jo lahko globalno obravnavate z middlewareom.
• Ločitev skrbi: Pomaga ločiti skrbi z izolacijo navzkrižnih funkcionalnosti, kot so avtentikacija, avtorizacija, beleženje in predpomnjenje, od poslovne logike vaših pogledov. To naredi vašo kodo čistejšo, bolj vzdržljivo in lažje razumljivo.
• Globalni vpliv: Middleware vpliva na vsako zahtevo in odgovor, kar ga dela močno orodje za uveljavljanje doslednega vedenja v vaši aplikaciji.
• Prilagodljivost in razširljivost: Sistem middlewarea Djanga je zelo prilagodljiv. Komponente middlewarea lahko enostavno dodajate, odstranjujete ali spreminjate, da prilagodite vedenje svoje aplikacije. Lahko napišete lasten middleware po meri za reševanje zelo specifičnih potreb, prilagojenih vašemu določenemu projektu.
• Optimizacija zmogljivosti: Določeni middleware, kot je middleware za predpomnjenje, lahko bistveno izboljša zmogljivost vaše aplikacije z zmanjšanjem obremenitve vaše baze podatkov in spletnega strežnika.

Kako deluje Django Middleware: Vrstni red obdelave

Vrstni red, v katerem so razredi middlewarea definirani v `settings.py`, je ključen. Django obdeluje middleware v določenem vrstnem redu, najprej med fazo zahteve (od zgoraj navzdol) in nato med fazo odgovora (od spodaj navzgor).

Faza zahteve: Middleware se uporablja za dohodno zahtevo v vrstnem redu, v katerem so definirani v nastavitvi `MIDDLEWARE`.

Faza odgovora: Odgovor gre skozi middleware v obratnem vrstnem redu. To pomeni, da bo zadnji middleware, definiran v vaši nastavitvi `MIDDLEWARE`, prvi obdelal odgovor, prvi middleware pa bo zadnji.

Razumevanje tega vrstnega reda je ključnega pomena za nadzor nad tem, kako vaš middleware medsebojno deluje in preprečuje nepričakovano vedenje.

Konfiguriranje Middlewarea v `settings.py`

Nastavitev `MIDDLEWARE` v datoteki `settings.py` je osrednja konfiguracijska točka za middleware. Gre za seznam nizov, od katerih vsak predstavlja pot do razreda middlewarea.

Tukaj je poenostavljen primer:

            MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

            

              
                Copy
              
            
          

Ta konfiguracija vključuje privzeti middleware Djanga, ki obravnava bistvene naloge. Svoj middleware po meri lahko dodate tako, da pot do razreda middlewarea dodate na ta seznam, pri čemer zagotovite, da je v pravilnem vrstnem redu glede na obstoječi middleware.

Pisanje lastnega Django Middlewarea

Ustvarjanje middlewarea po meri vključuje definiranje razreda Python s specifičnimi metodami, ki prestrezajo in spreminjajo cikel zahteve/odgovora. Ključne metode, ki jih lahko implementirate, so:

• `__init__(self, get_response)`: To se pokliče samo enkrat, ko se middleware inicializira. Običajno shranite klicljivo `get_response` kot instančno spremenljivko za kasnejšo uporabo. Ta parameter predstavlja naslednji middleware v verigi ali funkcijo pogleda, če je to zadnji middleware.
• `__call__(self, request)`: Ta metoda se pokliče ob vsaki zahtevi. Je jedro vašega middlewarea, kjer izvajate obdelavo. Prejme objekt zahteve kot vhod in mora vrniti bodisi objekt `HttpResponse` bodisi rezultat klica `get_response(request)`.
• `process_request(self, request)`: Pokliče se, preden se pokliče pogled. Prejme objekt zahteve. Objekt `request` lahko spremenite ali vrnete `HttpResponse`, da prekinete zahtevo. Če vrnete `None`, zahteva nadaljuje na naslednji middleware ali pogled.
• `process_view(self, request, view_func, view_args, view_kwargs)`: Pokliče se tik pred tem, ko Django pokliče pogled. Prejme objekt `request`, funkcijo pogleda in morebitne argumente, posredovane pogledu. Lahko spremenite zahtevo ali argumente pogleda. Vrnitev `HttpResponse` prekine proces.
• `process_response(self, request, response)`: Pokliče se po tem, ko je bil pogled poklican in je bil ustvarjen odgovor. Prejme objekt `request` in objekt `response`. Objekt `response` lahko spremenite. *Mora* vrniti objekt `response` (spremenjen ali nespremenjen).
• `process_exception(self, request, exception)`: Pokliče se, če med obdelavo zahteve pride do izjeme (bodisi v middlewareu ali v pogledu). Prejme objekt `request` in objekt izjeme. Lahko vrnete `HttpResponse` za obravnavo izjeme in prekinete proces, ali vrnete `None`, da Djangu omogočite obravnavo izjeme na privzeti način.

Primer: Preprost middleware po meri (beleženje zahtev)

Ustvarimo middleware za beleženje vsake dohodne zahteve. Ustvarite datoteko z imenom `middleware.py` v vaši aplikaciji Django.

            # In myapp/middleware.py
import logging

logger = logging.getLogger(__name__)

class RequestLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Code to be executed for each request before the view is called
        logger.info(f'Request received: {request.method} {request.path}')
        response = self.get_response(request)
        # Code to be executed for each request/response after the view is called
        return response

            

              
                Copy
              
            
          

Nato dodajte ta middleware v vaš `settings.py`:

            MIDDLEWARE = [
    # ... other middleware ...
    'myapp.middleware.RequestLoggingMiddleware',
]

            

              
                Copy
              
            
          

Sedaj, vsakič, ko pride zahteva, bo middleware zabeležil metodo zahteve in pot v vaše dnevnike.

Primer: Spreminjanje glav zahteve

Tukaj je primer middlewarea, ki doda glavo po meri vsakemu odgovoru:

            # In myapp/middleware.py
class AddCustomHeaderMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        response['X-Custom-Header'] = 'Hello from Middleware!'
        return response

            

              
                Copy
              
            
          

Ne pozabite tega dodati na seznam `MIDDLEWARE` v `settings.py`.

Pogosti primeri uporabe in primeri Django Middlewarea

Middleware je vsestranski. Tukaj je nekaj pogostih primerov uporabe:

• Avtentikacija in avtorizacija: Preverjanje uporabniških poverilnic in pravic dostopa, preden se dovoli dostop do določenih pogledov. To obravnava `AuthenticationMiddleware` Djanga. Middleware po meri lahko to razširi za podporo različnim metodam avtentikacije (npr. ključi API, OAuth) ali implementira nadzor dostopa na podlagi vlog.
• Upravljanje sej: Obravnava uporabniških sej za shranjevanje in pridobivanje podatkov, specifičnih za uporabnika. `SessionMiddleware` Djanga to obravnava privzeto.
• Zaščita pred CSRF: Zaščita pred napadi ponarejanja medstranskih zahtev (Cross-Site Request Forgery). `CsrfViewMiddleware` Djanga implementira zaščito CSRF.
• Stiskanje GZIP: Stiskanje odgovorov za zmanjšanje porabe pasovne širine in izboljšanje časa nalaganja strani. To obravnava `GZipMiddleware` Djanga.
• Beleženje in spremljanje: Beleženje zahtev, napak in metrik zmogljivosti. Prejšnji primer je prikazal beleženje zahtev. Middleware se lahko uporablja za integracijo z orodji za spremljanje.
• Politika varnosti vsebine (CSP): Nastavitev varnostnih glav za zaščito pred različnimi spletnimi ranljivostmi. Middleware lahko nastavi glavo `Content-Security-Policy` za omejitev virov vsebine, ki jo lahko naloži brskalnik.
• Predpomnjenje: Predpomnjenje pogosto dostopnih podatkov za izboljšanje zmogljivosti. Vgrajen predpomnilniški okvir Djanga in middlewarei tretjih oseb zagotavljajo to funkcionalnost.
• Preusmeritev URL-ja: Preusmerjanje uporabnikov na različne URL-je glede na določene pogoje (npr. uporabniška lokacija, vrsta naprave).
• Sprememba zahteve: Spreminjanje objekta zahteve (npr. dodajanje glav, nastavitev atributov zahteve). To se običajno uporablja za naloge, kot je nastavitev `REMOTE_ADDR`, če vaša aplikacija deluje za proxyjem.
• Sprememba odgovora: Spreminjanje objekta odgovora (npr. dodajanje glav, spreminjanje vsebine).
• Omejevanje hitrosti: Omejevanje števila zahtev z določenega IP naslova za preprečevanje zlorab.
• Internacionalizacija (i18n) in lokalizacija (l10n): Nastavitev jezika in lokacije za zahteve na podlagi uporabniških preferenc ali nastavitev brskalnika. To obravnava `LocaleMiddleware` Djanga.

Primer: Implementacija osnovne avtentikacije

Ustvarimo middleware, ki zahteva uporabniško ime in geslo za dostop do vseh strani (za demonstracijske namene, *ne* uporabljajte tega v produkciji brez ustreznih varnostnih pomislekov).

            # In myapp/middleware.py
from django.http import HttpResponse
from django.contrib.auth import authenticate, login

class BasicAuthMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if not request.user.is_authenticated:
            auth_header = request.META.get('HTTP_AUTHORIZATION')
            if auth_header:
                try:
                    auth_type, auth_string = auth_header.split(' ', 1)
                    if auth_type.lower() == 'basic':
                        import base64
                        auth_decoded = base64.b64decode(auth_string).decode('utf-8')
                        username, password = auth_decoded.split(':', 1)
                        user = authenticate(username=username, password=password)
                        if user is not None:
                            login(request, user)
                        else:
                            return HttpResponse('Unauthorized', status=401, headers={'WWW-Authenticate': 'Basic realm=\"Restricted Area\"'})
                except Exception:
                    return HttpResponse('Unauthorized', status=401, headers={'WWW-Authenticate': 'Basic realm=\"Restricted Area\"'})
            else:
                return HttpResponse('Unauthorized', status=401, headers={'WWW-Authenticate': 'Basic realm=\"Restricted Area\"'})
        return self.get_response(request)

            

              
                Copy
              
            
          

V `settings.py` dodajte to na `MIDDLEWARE`:

            MIDDLEWARE = [
    # ... other middleware ...
    'myapp.middleware.BasicAuthMiddleware',
]

            

              
                Copy
              
            
          

Ta middleware preverja osnovno glavo za avtentikacijo v vsaki zahtevi. Če je glava prisotna, poskuša avtenticirati uporabnika. Če avtentikacija ne uspe, vrne odgovor "Nepooblaščeno". Če avtentikacija uspe, pusti zahtevo, da gre skozi do pogledov.

Primer: Implementacija omejevanja hitrosti zahtev

Omejevanje hitrosti pomaga preprečiti zlorabe in ščiti vaš strežnik pred preobremenitvijo. Naslednji primer prikazuje poenostavljeno implementacijo.

            # In myapp/middleware.py
import time
from django.http import HttpResponse, HttpResponseTooManyRequests
from django.conf import settings

class RateLimitMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        self.requests = {}

    def __call__(self, request):
        ip_address = self.get_client_ip(request)
        now = time.time()

        if ip_address:
            if ip_address not in self.requests:
                self.requests[ip_address] = {
                    'count': 0,
                    'last_request': now
                }
            
            if settings.RATE_LIMIT_WINDOW:
                if now - self.requests[ip_address]['last_request'] > settings.RATE_LIMIT_WINDOW:
                    self.requests[ip_address]['count'] = 0
                    self.requests[ip_address]['last_request'] = now

            self.requests[ip_address]['count'] += 1
            self.requests[ip_address]['last_request'] = now

            if settings.RATE_LIMIT_REQUESTS and self.requests[ip_address]['count'] > settings.RATE_LIMIT_REQUESTS:
                return HttpResponseTooManyRequests('Too many requests.')

        return self.get_response(request)

    def get_client_ip(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0].strip()
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip

            

              
                Copy
              
            
          

V vašem `settings.py` določite te nastavitve:

            RATE_LIMIT_REQUESTS = 10  # Max requests per window
RATE_LIMIT_WINDOW = 60  # Seconds

            

              
                Copy
              
            
          

Dodajte to na `MIDDLEWARE`:

            MIDDLEWARE = [
    # ... other middleware ...
    'myapp.middleware.RateLimitMiddleware',
]

            

              
                Copy
              
            
          

Ta middleware omejuje zahteve na podlagi IP naslova odjemalca. Prilagodite `RATE_LIMIT_REQUESTS` in `RATE_LIMIT_WINDOW` za konfiguracijo omejevanja hitrosti.

Najboljše prakse za razvoj Django Middlewarea

Upoštevanje teh najboljših praks zagotavlja, da je vaš middleware učinkovit, vzdržljiv in ne povzroča ozkih grl v zmogljivosti:

• Naj bo preprosto: Middleware naj se osredotoča na specifične, dobro definirane naloge. Izogibajte se kompleksni logiki ali pretiranim odvisnostim.
• Bodite zmogljivi: Middleware se izvede pri vsaki zahtevi/odgovoru. Optimizirajte svojo kodo, da zmanjšate čas obdelave. Izogibajte se blokirnim operacijam ali nepotrebnim poizvedbam v bazi podatkov znotraj vašega middlewarea.
• Temeljito testirajte: Napišite enotske teste, da zagotovite, da vaš middleware deluje pravilno in se obnaša, kot je pričakovano v različnih scenarijih. Preizkusite mejne primere in obravnavo napak.
• Jasno dokumentirajte: Zagotovite jasno dokumentacijo, ki pojasnjuje, kaj vaš middleware dela, kako deluje in kako ga konfigurirati. Vključite primere in navodila za uporabo.
• Upoštevajte konvencije Djanga: Upoštevajte kodirni slog in konvencije Djanga. To naredi vašo kodo bolj berljivo in lažje razumljivo za druge razvijalce.
• Upoštevajte vpliv na zmogljivost: Skrbno ocenite potencialni vpliv vašega middlewarea na zmogljivost, še posebej, če vključuje operacije, ki porabijo veliko virov.
• Obravnavajte izjeme elegantno: Implementirajte pravilno obravnavo napak, da preprečite, da bi vaš middleware zrušil vašo aplikacijo. Uporabite bloke `try...except` za lovljenje potencialnih izjem in beleženje napak. Uporabite `process_exception()` za celovito obravnavo izjem.
• Vrstni red je pomemben: Skrbno pretehtajte vrstni red vašega middlewarea v nastavitvi `MIDDLEWARE`. Zagotovite, da je middleware postavljen v pravilnem vrstnem redu, da dosežete želeno vedenje in se izognete konfliktom.
• Izogibajte se nepotrebnemu spreminjanju zahteve/odgovora: Spremenite objekte zahteve/odgovora le, kadar je to potrebno za dosego želenega vedenja. Nepotrebne spremembe lahko vodijo do težav z zmogljivostjo.

Napredne tehnike in premisleki pri middlewareu

Poleg osnov, tukaj so nekatere napredne tehnike:

• Uporaba middlewarea za asinhrona opravila: Middleware lahko uporabite za sprožanje asinhronih opravil, kot je pošiljanje e-pošte ali obdelava podatkov v ozadju. Za obravnavo teh operacij uporabite Celery ali druge čakalne vrste opravil.
• Tovarniške funkcije middlewarea: Za bolj kompleksne konfiguracije lahko uporabite tovarnice middlewarea (middleware factories), ki so funkcije, ki sprejemajo konfiguracijske argumente in vračajo razrede middlewarea. To je koristno, ko morate inicializirati middleware s parametri, definiranimi v `settings.py`.
• Pogojni middleware: Middleware lahko pogojno omogočite ali onemogočite na podlagi nastavitev ali okoljskih spremenljivk. To vam omogoča, da prilagodite vedenje vaše aplikacije za različna okolja (npr. razvoj, testiranje, produkcija).
• Middleware za omejevanje hitrosti API-ja: Implementirajte sofisticirane tehnike omejevanja hitrosti za vaše API končne točke. Razmislite o uporabi knjižnic tretjih oseb ali specializiranih storitev, kot je Redis, za shranjevanje podatkov o omejevanju hitrosti.
• Integracija z knjižnicami tretjih oseb: Svoj middleware lahko brezhibno integrirate z knjižnicami in orodji tretjih oseb. Na primer, integrirajte se z orodji za spremljanje za zbiranje metrik in sledenje zmogljivosti.

Primer: Uporaba tovarniške funkcije middlewarea

Ta primer prikazuje preprosto tovarniško funkcijo middlewarea. Ta pristop vam omogoča, da posredujete konfiguracijske parametre iz datoteke `settings.py`.

            # In myapp/middleware.py
from django.conf import settings

def my_middleware_factory(setting_key):
    class MyConfigurableMiddleware:
        def __init__(self, get_response):
            self.get_response = get_response
            self.config_value = settings.get(setting_key, 'default_value')  # Read config

        def __call__(self, request):
            # Use self.config_value
            print(f'Config value: {self.config_value}')
            return self.get_response(request)
    return MyConfigurableMiddleware

            

              
                Copy
              
            
          

V `settings.py` jo konfigurirajte takole:

            MIDDLEWARE = [
    # ... other middleware ...
    'myapp.middleware.my_middleware_factory', # Note: Pass it without parenthesis or arguments.
]
MY_CUSTOM_SETTING = 'some_value'

            

              
                Copy
              
            
          

In v `urls.py` ali katerem koli drugem mestu, kjer se middleware uporablja, lahko tovarniški metodi posredujete konfiguracijsko nastavitev:

            from myapp.middleware import my_middleware_factory

urlpatterns = [
    # ...other url patterns...
    #  No arguments needed for the factory method in URL configuration
]

            

              
                Copy
              
            
          

Ta pristop zagotavlja večjo prilagodljivost in možnost prilagoditve.

Pogoste težave in odpravljanje napak

Tukaj je nekaj pogostih težav, s katerimi se lahko srečate pri delu z Django middlewareom, skupaj z rešitvami:

• Nepravilen vrstni red middlewarea: Če se vaš middleware ne obnaša, kot je pričakovano, dvakrat preverite vrstni red v `settings.py`. Vrstni red je kritičen.
• Napake med obdelavo zahtev: Če vaš middleware vrže napako, lahko prekine celoten cikel zahteve. Uporabite metodo `process_exception()` za elegantno obravnavo izjem in preprečevanje nepričakovanih napak. Prepričajte se tudi, da vaš middleware nima krožnih odvisnosti.
• Ozka grla v zmogljivosti: Neučinkovit middleware lahko upočasni vašo aplikacijo. Profilirajte svojo kodo, da prepoznate ozka grla v zmogljivosti in jo ustrezno optimizirajte. Izogibajte se operacijam, ki porabijo veliko virov znotraj middlewarea, ali pa jih prenesite na opravila v ozadju.
• Konflikt z drugim middlewareom: Zavedajte se, da se vaš middleware lahko spopada z drugim middlewareom v vašem projektu ali celo s privzetim middlewareom Djanga. Skrbno preglejte dokumentacijo in zagotovite, da vsi middlewarei pravilno medsebojno delujejo.
• Nenamerni stranski učinki: Zagotovite, da vaš middleware spreminja objekte zahteve/odgovora le na predviden način. Izogibajte se nenamernim stranskim učinkom, ki bi lahko vodili do nepričakovanega vedenja.
• Težave s sejami: Če imate težave, povezane s sejami, se prepričajte, da je `SessionMiddleware` pravilno konfiguriran v datoteki `settings.py` in da se podatki seje pravilno shranjujejo in dostopajo.
• Težave z žetoni CSRF: Če se soočate s težavami, povezanimi z žetoni CSRF, se prepričajte, da je `CsrfViewMiddleware` pravilno v `settings.py`. Prav tako dvakrat preverite svoje obrazce za pravilno upodabljanje žetonov csrf.

Uporabite vgrajena orodja za odpravljanje napak in beleženje Djanga za iskanje težav. Analizirajte življenjski cikel zahteve/odgovora, da prepoznate glavni vzrok morebitnih težav. Temeljito testiranje vašega middlewarea pred namestitvijo je prav tako ključnega pomena.

Zaključek: Obvladovanje Django Middlewarea

Django middleware je temeljni koncept za vsakega razvijalca Djanga. Razumevanje, kako deluje, kako ga konfigurirati in kako ustvariti middleware po meri, je ključnega pomena za gradnjo robustnih, vzdržljivih in razširljivih spletnih aplikacij.

Z obvladovanjem middlewarea pridobite močan nadzor nad potekom obdelave zahtev vaše aplikacije, kar vam omogoča implementacijo širokega spektra funkcionalnosti, od avtentikacije in avtorizacije do optimizacije zmogljivosti in varnostnih izboljšav.

Ko se vaši projekti povečujejo v kompleksnosti, bo sposobnost učinkovite uporabe middlewarea postala bistvena veščina. Nadaljujte z vadbo in eksperimentiranjem in postali boste vešči izkoriščanja moči sistema middlewarea Djanga.